JavaSE - 反射

来自：https://blog.csdn.net/qq_44715943/article/details/120587716

什么是反射机制

JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的法的功能称为 Java 语言的反射机制。

反射机制作用

通过 Java 语言中的反射机制可以操作字节码文件（可以读和修改字节码)文件）
通过反射机制可以操作代码片段（Class 文件）

反射机制的相关类：java.lang.reflect.*

反射机制相关的重要的类

类	含义
java.lang.Class	代表整个字节码。代表一个类型，代表整个类。
java.lang.reflect.Method	代表字节码中的方法字节码。代表类中的方法。
java.lang.reflect.Constructor	代表字节码中的构造方法字节码。代表类中的构造方法。
java.lang.reflect.Field	代表字节码中的属性字节码。代表类中的成员变量（静态变量 + 实例变量）。

注：必须先获得 Class 才能获取 Method、Constructor、Field。

java

public class User{
	// Field
	int no;

	// Constructor
	public User(){

	}
	public User(int no){
		this.no = no;
	}

	// Method
	public void setNo(int no){
		this.no = no;
	}
	public int getNo(){
		return no;
	}
}

获取 Class 的三方式

要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取 java.lang.Class 实例？

方式	备注
Class.forName("完整类名带包名")	静态方法
对象.getClass()
任何类型.class

注：以上三种方式返回值都是 Class 类型。

通过反射实例化对象

java

对象.newInstance()

注：newInstance() 方法内部实际上调用了 无参数构造方法，必须保证无参构造存在才可以，否则会抛出 java.lang.InstantiationException 异常。

java

class ReflectTest02{
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // 下面这段代码是以反射机制的方式创建对象。

        // 通过反射机制，获取 Class，通过 Class 来实例化对象
        Class c = Class.forName("javase.reflectBean.User");
        // newInstance() 这个方法会调用 User 这个类的无参数构造方法，完成对象的创建。
        // 重点是：newInstance() 调用的是无参构造，必须保证无参构造是存在的！
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

导致类加载

如果你只是希望一个类的 静态代码块 执行，其它代码一律不执行，可以使用：

java

Class.forName("完整类名");

这个方法的执行会导致 类加载，类加载时，静态代码块执行。

反射 Filed

Class 类方法

方法名	备注
public T newInstance()	创建对象
public String getName()	返回完整类名带包名
public String getSimpleName()	返回类名
public Field[] getFields()	返回类中 public 修饰的属性
public Field[] getDeclaredFields()	返回类中所有的属性
public Field getDeclaredField(String name)	根据属性名 name 获取指定的属性
public native int getModifiers()	获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号（一般配合 Modifier 类的 `toString(int x)` 方法使用）
public Method[] getDeclaredMethods()	返回类中所有的实例方法
public Method getDeclaredMethod(String name, Class<?>… parameterTypes)	根据方法名 name 和方法形参获取指定方法
public Constructor<?>[] getDeclaredConstructors()	返回类中所有的构造方法
public Constructor getDeclaredConstructor(Class<?>… parameterTypes)	根据方法形参获取指定的构造方法
---	---
public native Class<? super T> getSuperclass()	返回调用类的父类
public Class<?>[] getInterfaces()	返回调用类实现的接口集合

Field 类方法

方法名	备注
public String getName()	返回属性名
public int getModifiers()	获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号（一般配合 Modifier 类的 `toString(int x)` 方法使用）
public Class<?> getType()	以 Class 类型，返回属性类型（一般配合 Class 类的 `getSimpleName()` 方法使用）
public void set(Object obj, Object value)	设置属性值
public Object get(Object obj)	读取属性值

反编译 Field

java

// 通过反射机制，反编译一个类的属性 Field（了解一下）
class ReflectTest06{
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s = new StringBuilder();

        Class studentClass = Class.forName("javase.reflectBean.Student");
        // Class 类的 getName方法
        s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {\n");
        // 获取所有的属性
        Field[] fields = studentClass.getDeclaredFields();
        for (Field f : fields){
            s.append("\t");
            // 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号
            // 用 Modifier 类的 toString 转换成字符串
            s.append(Modifier.toString(f.getModifiers()));
            if (f.getModifiers() != 0) s.append(" ");
            s.append(f.getType().getSimpleName()); // 获取属性的类型
            s.append(" ");
            s.append(f.getName()); // 获取属性的名字
            s.append(";\n");
        }
        s.append("}");
        System.out.println(s);
    }
}

注： Field 类中 set()、get() 使用注意事项：

java

属性.set(对象, 值);

属性.get(对象);

访问对象属性

java

/*
必须掌握：怎么通过反射机制访问一个 Java 对象的属性？
        给属性赋值 set
        获取属性的值 get
 */
class ReflectTest07{
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        // 不使用反射机制给属性赋值
        Student student = new Student();
        /** 给属性赋值三要素：给 s 对象的 no 属性赋值 1111
         * 要素 1：对象 s
         * 要素 2：no 属性
         * 要素 3：1111
         */
        student.no = 1111;
        /**读属性值两个要素：获取 s 对象的 no 属性的值
         * 要素 1：对象 s
         * 要素 2：no 属性
         */
        System.out.println(student.no);

        // 使用反射机制给属性赋值
        Class studentClass = Class.forName("javase.reflectBean.Student");
        Object obj = studentClass.newInstance();// obj就是Student对象。（底层调用无参数构造方法）

        // 获取 no 属性（根据属性的名称来获取 Field）
        Field noField = studentClass.getDeclaredField("no");
        // 给 obj 对象(Student 对象)的 no 属性赋值
        /*
            虽然使用了反射机制，但是三要素还是缺一不可：
                要素 1：obj 对象
                要素 2：no 属性
                要素 3：22222 值
            注意：反射机制让代码复杂了，但是为了一个「灵活」，这也是值得的。
         */
        noField.set(obj, 22222);

        // 读取属性的值
        // 两个要素：获取 obj 对象的 no 属性的值。
        System.out.println(noField.get(obj));
    }
}

set()可以访问私有属性嘛？

默认不可以，需要打破封装，才可以。

方法	备注
public void setAccessible(boolean flag)	默认 false，设置为 true 为打破封装

java

public class Test {
    public void static main() {
        // 可以访问私有的属性吗？
        Field nameField = studentClass.getDeclaredField("name");
        // 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会）
        // 这样设置完之后，在外部也是可以访问 private 的
        nameField.setAccessible(true);
        // 给 name 属性赋值
        nameField.set(obj, "xiaowu");
        // 获取 name 属性的值
        System.out.println(nameField.get(obj));
    }
}

反射 Method

Method 类方法

方法名	备注
public String getName()	返回方法名
public int getModifiers()	获取方法的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号（一般配合 Modifier 类的 `toString(int x)` 方法使用）
public Class<?> getReturnType()	以 Class 类型，返回方法类型（一般配合 Class 类的 `getSimpleName()` 方法使用）
public Class<?>[] getParameterTypes()	返回方法的修饰符列表，（一个方法的参数可能会有多个），结果集一般配合 Class 类的 `getSimpleName()` 方法使用
public Object invoke(Object obj, Object… args)	调用方法

反编译 Method

java

/*
   了解一下，不需要掌握（反编译一个类的方法）
 */
class ReflectTest09{
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s = new StringBuilder();

        Class userServiceClass = Class.forName("java.lang.String");

        s.append(Modifier.toString(userServiceClass.getModifiers()));
        s.append(" class ");
        s.append(userServiceClass.getSimpleName());
        s.append(" {\n");

        // 获取所有的Method（包括私有的！）
        Method[] methods = userServiceClass.getDeclaredMethods();
        for (Method m : methods){
            s.append("\t");
            // 获取修饰符列表
            s.append(Modifier.toString(m.getModifiers()));
            s.append(" ");
            // 获取方法的返回值类型
            s.append(m.getReturnType().getSimpleName());
            s.append(" ");
            // 获取方法名
            s.append(m.getName());
            s.append("(");
            // 方法的修饰符列表（一个方法的参数可能会有多个。）
            Class[] parameterTypes = m.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++){
                s.append(parameterTypes[i].getSimpleName());
                if (i != parameterTypes.length - 1) s.append(", ");
            }
            s.append(") {}\n");
        }
        s.append("}");
        System.out.println(s);
    }
}

注： Method 类中 invoke() 使用注意事项：

java

方法.invoke(对象, 实参);

调用对象方法

java

/*
重点：必须掌握，通过反射机制怎么调用一个对象的方法？

    反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
    将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
    但是 java 代码不需要做任何改动。这就是反射机制的魅力。
 */
class ReflectTest10{
    public static void main(String[] args) throws Exception {
        // 不使用反射机制，怎么调用方法
        // 创建对象
        UserService userService = new UserService();
        // 调用方法
        /*
            要素分析：
                要素1：对象 userService
                要素2：login 方法名
                要素3：实参列表
                要素4：返回值
         */
        System.out.println(userService.login("admin", "123") ? "登入成功！" : "登入失败！");

        //使用反射机制调用方法
        Class userServiceClass = Class.forName("javase.reflectBean.UserService");
        // 创建对象
        Object obj = userServiceClass.newInstance();
        // 获取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        // Method loginMethod = userServiceClass.getDeclaredMethod("login");//注：没有形参就不传
        // 调用方法
        // 调用方法有几个要素？ 也需要 4 要素。
        // 反射机制中最最最最最重要的一个方法，必须记住。
        /*
            四要素：
            loginMethod 方法
            obj 对象
            "admin","123" 实参
            retValue 返回值
         */
        Object resValues = loginMethod.invoke(obj, "admin", "123");//注：方法返回值是void 结果是null
        System.out.println(resValues);
    }
}

反射 Constructor

Constructor 类方法

方法名	备注
public String getName()	返回构造方法名
public int getModifiers()	获取构造方法的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号（一般配合 Modifier 类的 `toString(int x)` 方法使用）
public Class<?>[] getParameterTypes()	返回构造方法的修饰符列表，（一个方法的参数可能会有多个）结果集一般配合 Class 类的 `getSimpleName()` 方法使用
public T newInstance(Object … initargs)	创建对象（参数为创建对象的数据）

反编译 Constructor

java

/*
  反编译一个类的 Constructor 构造方法。
 */
class ReflectTest11{
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s = new StringBuilder();

        Class vipClass = Class.forName("javase.reflectBean.Vip");

        // public class UserService {
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append(" class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        Constructor[] constructors = vipClass.getDeclaredConstructors();
        for (Constructor c : constructors){
            // public Vip(int no, String name, String birth, boolean sex) {
            s.append("\t");
            s.append(Modifier.toString(c.getModifiers()));
            s.append(" ");
            // s.append(c.getName()); // 包名 + 类名
            s.append(vipClass.getSimpleName()); // 类名
            s.append("(");
            Class[] parameterTypes = c.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++){
                s.append(parameterTypes[i].getSimpleName());
                if (i != parameterTypes.length - 1 ) s.append(", ");
            }
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

创建对象两步骤

先获取到这个有参数的构造方法，用 `ClassgetDeclaredConstructor() 方法获取
调用构造方法 new 对象，用 Constructor 类的 newInstance() 方法 new 对象

构造方法实例化对象

java

/*
 通过反射机制调用构造方法实例化 java 对象。
 */
class ReflectTest12{
    public static void main(String[] args) throws Exception {
        // 不适用反射创建对象
        Vip vip1 = new Vip();
        Vip vip2 = new Vip(123, "zhangsan", "2001-10-19", false);

        // 使用反射机制创建对象（以前）
        Class vipClass = Class.forName("javase.reflectBean.Vip");
        // 调用无参数构造方法
        Object obj1 = vipClass.newInstance();//Class类的newInstance方法
        System.out.println(obj1);

        // 使用反射机制创建对象（现在）
        // 调用有参数的构造方法怎么办？
        // 第一步：先获取到这个有参数的构造方法
        Constructor c1 = vipClass.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);
        // 第二步：调用构造方法 new 对象
        Object obj2 = c1.newInstance(321, "lsi", "1999-10-11", true);//Constructor类的newInstance方法
        System.out.println(obj2);

        // 获取无参数构造方法
        Constructor c2 = vipClass.getDeclaredConstructor();
        Object obj3 = c2.newInstance();
        System.out.println(obj3);
    }
}

注：如果需要调用无参构造方法，getDeclaredConstructor() 方法形参为空即可，和 Class 类的 newInstance() 方法一样的效果。

获取类的父类以及实现的接口

Class 类中的两个方法：

public native Class<? super T> getSuperclass()
public Class<?>[] getInterfaces()

java

/*
  重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
 */
class ReflectTest13{
    public static void main(String[] args) throws Exception{
        // String 举例
        Class vipClass = Class.forName("java.lang.String");
        // 获取 String 的父类
        Class superclass = vipClass.getSuperclass();
        // 获取 String 类实现的所有接口（一个类可以实现多个接口）
        Class[] interfaces = vipClass.getInterfaces();
        System.out.println(superclass.getName());
        for (Class i : interfaces) {
            System.out.println(i.getName());
        }
    }
}

注意

属性最重要的是名字
实例方法最重要的是名字和 形参列表
构造方法最重要的是 形参列表

测试代码

java

/*
要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取 java.lang.Class 实例？
    三种方式
        第一种：Class c = Class.forName("完整类名带包名");
        第二种：Class c = 对象.getClass();
        第三种：Class c = 任何类型.class;

 */
class ReflectTest01 {
    public static void main(String[] args) throws ClassNotFoundException{
        /*
        第一种方式：Class.forName()
            1、静态方法
            2、方法的参数是一个字符串。
            3、字符串需要的是一个完整类名。
            4、完整类名必须带有包名。java.lang 包也不能省略。
         */
        Class c1 = Class.forName("java.lang.String"); // c1 代表 String.class 文件，或者说 c1 代表 String 类型。
        Class c2 = Class.forName("java.lang.Integer"); // c2 代表 Integer 类型
        Class c3 = Class.forName("java.util.Date"); // c3 代表 Date 类型


        // 第二种方式：java 中任何一个对象都有一个方法：getClass()
        String a = "abc";
        Class c4 = a.getClass(); // c4 代表S tring.class 字节码文件；c4 代表 String 类型。
        System.out.println(c4 == c1); // true（判断的是对象的内存地址）

        Date time = new Date();
        Class c5 = time.getClass();
        System.out.println(c5 == c3); // true（c5 和 c3 两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件）

        // 第三种方式：java 语言中任何一种类型，包括基本数据类型，它都有 .class 属性。
        Class i = Integer.class; // i 代表 Integer 类型
        Class d = Date.class; // d 代表 Date 类型
        Class f = float.class; // f 代表 float 类型

        System.out.println(i == c2);//true
    }
}

/*
获取到 Class，能干什么？
    通过 Class 的 newInstance() 方法来实例化对象。
    注意：newInstance() 方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以。
 */
class ReflectTest02{
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // 下面这段代码是以反射机制的方式创建对象。

        // 通过反射机制，获取 Class，通过 Class 来实例化对象
        Class c = Class.forName("javase.reflectBean.User");
        // newInstance() 这个方法会调用 User 这个类的无参数构造方法，完成对象的创建。
        // 重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的！
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

/*
验证反射机制的灵活性。
    java 代码写一遍，再不改变 java 源代码的基础之上，可以做到不同对象的实例化。
    非常之灵活。（符合 OCP 开闭原则：对扩展开放，对修改关闭。）
 */
class ReflectTest03{
    public static void main(String[] args) throws Exception{
        // 以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
        // 通过 IO 流读取 reflectClassInfo.properties 文件
        FileReader reader = new FileReader("Practice/reflectClassInfo1.properties");
        // 创建属性类对象 Map
        Properties pro = new Properties();// key value 都是 String
        // 加载
        pro.load(reader);
        reader.close();

        // 通过 key 获取 value
        String className = pro.getProperty("className");

        // 通过反射机制实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

/*
研究一下：Class.forName() 发生了什么？
    记住，重点：
        如果你只是希望一个类的静态代码块执行，其它代码一律不执行，
        你可以使用：
            Class.forName("完整类名");
        这个方法的执行会导致类加载，类加载时，静态代码块执行。

提示：
    后面 JDBC 技术的时候我们还需要。
 */
class ReflectTest04{
    public static void main(String[] args) throws ClassNotFoundException {
        // Class.forName()这个方法的执行会导致：类加载。
        Class.forName("javase.MyClass");
    }
}
class MyClass{
    static {
        System.out.println("MyClass中的静态代码块执行了！");
    }
}

/*
  研究一下文件路径的问题。
  怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。但前提是：文件需要在类路径下。才能用这种方式。
 */
class AboutPath{
    public static void main(String[] args) throws FileNotFoundException {
        // 这种方式的路径缺点是：移植性差，在 IDEA 中默认的当前路径是 project 的根。
        // 这个代码假设离开了 IDEA，换到了其它位置，可能当前路径就不是 project 的根了，这时这个路径就无效了。
        File reader = new File("Practice/src/reflectClassInfo2.properties");
        System.out.println(reader.exists() + " " + reader.getPath());

        // 接下来说一种比较通用的一种路径。即使代码换位置了，这样编写仍然是通用的。
        // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
        // 什么类路径下？方式在 src 下的都是类路径下。【记住它】
        // src 是类的根路径。
        /*
        解释：
            Thread.currentThread() 当前线程对象
            getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
            getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
         */
        String path = Thread.currentThread().getContextClassLoader().getResource("reflectClassInfo2.properties").getPath();
        // 采用以上的代码可以拿到一个文件的绝对路径。
        // /D:/996-CodeSection/001-IDEA/0.JavaSE/TestProject/out/production/practice/reflectClassInfo2.properties
        System.out.println(path);

        String path2 = Thread.currentThread().getContextClassLoader().getResource("javase/reflectBean/db.properties").getPath();
        // /D:/996-CodeSection/001-IDEA/0.JavaSE/TestProject/out/production/practice/javase/reflectBean/db.properties
        System.out.println(path2);
    }
}

class IoPropertiesTest{
    public static void main(String[] args) throws IOException {
        // 以前
        /*String path = Thread.currentThread().getContextClassLoader().getResource("reflectClassInfo2.properties").getPath();
        FileReader reader = new FileReader(path);*/

        // 现在
        // 直接以流的形式返回。
        InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("reflectClassInfo2.properties");
        Properties pro = new Properties();
        pro.load(reader);
        reader.close();
        // 通过 key 获取 value
        String className = pro.getProperty("className");
        System.out.println(className);// java.util.Date

    }
}

/*
  java.util 包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
  使用以下这种方式的时候，属性配置文件 xxx.properties 必须放到类路径下。
 */
class ResourceBundleTest{
    public static void main(String[] args) {
        // 资源绑定器，只能绑定 xxx.properties 文件。并且这个文件必须在类路径下。文件扩展名也必须是 properties
        // 并且在写路径的时候，路径后面的扩展名不能写。
        // ResourceBundle bundle = ResourceBundle.getBundle("reflectClassInfo2");
        ResourceBundle bundle = ResourceBundle.getBundle("javase/reflectBean/db");
        String className = bundle.getString("className");
        System.out.println(className);

    }
}

/*
  反射 Student 类当中所有的 Field（了解一下）
 */
class ReflectTest05{
    public static void main(String[] args) throws Exception {
        Class studentClass = Class.forName("javase.reflectBean.Student");

        String className = studentClass.getName(); // Class 类的 getName 方法
        System.out.println("完整类名： " + className);
        String simpleName = studentClass.getSimpleName(); // Class 类的 getName 方法
        System.out.println("简类名： " + simpleName);

        // 获取 public 修饰的属性
        Field[] fields1 = studentClass.getFields();
        System.out.println(fields1.length);// 2
        System.out.println(fields1[0].getName() + " " + fields1[1].getName()); // Field 类中的 getName 犯法

        System.out.println("----------------------");

        // 获取所有的属性
        Field[] fields2 = studentClass.getDeclaredFields();
        System.out.println(fields2.length);
        for (Field f : fields2){
            System.out.println(f.getName());
        }

        System.out.println("----------------------");

        // 获取属性的修饰符列表
        for (Field f : fields2){
            // 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号
            // 用 Modifier 类的 toString 转换成字符串
            System.out.println(Modifier.toString(f.getModifiers()));
            System.out.println(f.getType().getSimpleName());// 获取属性的类型
            System.out.println(f.getName());// 获取属性的名字
        }
    }
}

// 通过反射机制，反编译一个类的属性 Field（了解一下）
class ReflectTest06{
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s = new StringBuilder();

        Class studentClass = Class.forName("javase.reflectBean.Student");
        // Class 类的 getName 方法
        s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {\n");
        // 获取所有的属性
        Field[] fields = studentClass.getDeclaredFields();
        for (Field f : fields){
            s.append("\t");
            // 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号
            // 用 Modifier 类的 toString 转换成字符串
            s.append(Modifier.toString(f.getModifiers()));
            if (f.getModifiers() != 0) s.append(" ");
            s.append(f.getType().getSimpleName()); // 获取属性的类型
            s.append(" ");
            s.append(f.getName()); // 获取属性的名字
            s.append(";\n");
        }
        s.append("}");
        System.out.println(s);
    }
}

/*
必须掌握：
    怎么通过反射机制访问一个 java 对象的属性？
        给属性赋值 set
        获取属性的值 get
 */
class ReflectTest07{
    public static void main(String[] args) throws Exception {
        // 不使用反射机制给属性赋值
        Student student = new Student();
        /** 给属性赋值三要素：给s对象的 no 属性赋值 1111
         * 要素1：对象s
         * 要素2：no 属性
         * 要素3：1111
         */
        student.no = 1111;
        /** 读属性值两个要素：获取 s 对象的 no 属性的值。
         * 要素 1：对象 s
         * 要素 2：no 属性
         */
        System.out.println(student.no);

        // 使用反射机制给属性赋值
        Class studentClass = Class.forName("javase.reflectBean.Student");
        Object obj = studentClass.newInstance();// obj就是Student对象。（底层调用无参数构造方法）

        // 获取 no 属性（根据属性的名称来获取 Field）
        Field noField = studentClass.getDeclaredField("no");
        // 给 obj 对象(Student 对象)的 no 属性赋值
        /*
            虽然使用了反射机制，但是三要素还是缺一不可：
                要素1：obj对象
                要素2：no属性
                要素3：22222值
            注意：反射机制让代码复杂了，但是为了一个「灵活」，这也是值得的。
         */
        noField.set(obj, 22222);

        // 读取属性的值
        // 两个要素：获取 obj 对象的 no 属性的值。
        System.out.println(noField.get(obj));


        // 可以访问私有的属性吗？
        Field nameField = studentClass.getDeclaredField("name");
        // 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会）
        // 这样设置完之后，在外部也是可以访问 private 的。
        nameField.setAccessible(true);
        // 给name属性赋值
        nameField.set(obj, "xiaowu");
        // 获取 name 属性的值
        System.out.println(nameField.get(obj));
    }
}

/*
  作为了解内容（不需要掌握）：
     反射Method
 */
class ReflectTest08{
    public static void main(String[] args) throws ClassNotFoundException {
        Class userServiceClass = Class.forName("javase.reflectBean.UserService");
        // 获取所有的 Method（包括私有的）
        Method[] methods = userServiceClass.getDeclaredMethods();
        for (Method m : methods){
            // 获取修饰符列表
            System.out.println(Modifier.toString(m.getModifiers()));
            // 获取方法的返回值类型
            System.out.println(m.getReturnType().getSimpleName());
            // 获取方法名
            System.out.println(m.getName());
            // 方法的修饰符列表（一个方法的参数可能会有多个）
            Class[] parameterTypes = m.getParameterTypes();
            for (Class pts : parameterTypes){
                System.out.println(pts.getSimpleName());
            }
            System.out.println("------------------------");
        }
    }
}

/*
  了解一下，不需要掌握（反编译一个类的方法。）
 */
class ReflectTest09{
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s = new StringBuilder();

        Class userServiceClass = Class.forName("java.lang.String");

        s.append(Modifier.toString(userServiceClass.getModifiers()));
        s.append(" class ");
        s.append(userServiceClass.getSimpleName());
        s.append(" {\n");

        // 获取所有的 Method（包括私有的）
        Method[] methods = userServiceClass.getDeclaredMethods();
        for (Method m : methods){
            s.append("\t");
            // 获取修饰符列表
            s.append(Modifier.toString(m.getModifiers()));
            s.append(" ");
            // 获取方法的返回值类型
            s.append(m.getReturnType().getSimpleName());
            s.append(" ");
            // 获取方法名
            s.append(m.getName());
            s.append("(");
            // 方法的修饰符列表（一个方法的参数可能会有多个）
            Class[] parameterTypes = m.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++){
                s.append(parameterTypes[i].getSimpleName());
                if (i != parameterTypes.length - 1) s.append(", ");
            }
            s.append(") {}\n");
        }
        s.append("}");
        System.out.println(s);
    }
}

/*
重点：必须掌握，通过反射机制怎么调用一个对象的方法？

    反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
    将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
    但是 java 代码不需要做任何改动。这就是反射机制的魅力。
 */
class ReflectTest10{
    public static void main(String[] args) throws Exception {
        // 不使用反射机制，怎么调用方法
        // 创建对象
        UserService userService = new UserService();
        // 调用方法
        /*
            要素分析：
                要素 1：对象 userService
                要素 2：login 方法名
                要素 3：实参列表
                要素 4：返回值
         */
        System.out.println(userService.login("admin", "123") ? "登入成功！" : "登入失败！");

        // 使用反射机制调用方法
        Class userServiceClass = Class.forName("javase.reflectBean.UserService");
        // 创建对象
        Object obj = userServiceClass.newInstance();
        // 获取 Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        // Method loginMethod = userServiceClass.getDeclaredMethod("login"); // 注：没有形参就不传
        // 调用方法
        // 调用方法有几个要素？ 也需要4要素。
        // 反射机制中最最最最最重要的一个方法，必须记住。
        /*
            四要素：
            loginMethod 方法
            obj 对象
            "admin","123" 实参
            retValue 返回值
         */
        Object resValues = loginMethod.invoke(obj, "admin", "123");//注：方法返回值是void 结果是null
        System.out.println(resValues);
    }
}

/*
  反编译一个类的 Constructor 构造方法。
 */
class ReflectTest11{
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s = new StringBuilder();

        Class vipClass = Class.forName("javase.reflectBean.Vip");

        // public class UserService {
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append(" class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        Constructor[] constructors = vipClass.getDeclaredConstructors();
        for (Constructor c : constructors){
            // public Vip(int no, String name, String birth, boolean sex) {
            s.append("\t");
            s.append(Modifier.toString(c.getModifiers()));
            s.append(" ");
            // s.append(c.getName()); // 包名 + 类名
            s.append(vipClass.getSimpleName()); // 类名
            s.append("(");
            Class[] parameterTypes = c.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++){
                s.append(parameterTypes[i].getSimpleName());
                if (i != parameterTypes.length - 1 ) s.append(", ");
            }
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

/*
 比上一个例子(ReflectTest11)重要一些！！！

 通过反射机制调用构造方法实例化 java 对象（这个不是重点）
 */
class ReflectTest12{
    public static void main(String[] args) throws Exception {
        // 不适用反射创建对象
        Vip vip1 = new Vip();
        Vip vip2 = new Vip(123, "zhangsan", "2001-10-19", false);

        // 使用反射机制创建对象（以前）
        Class vipClass = Class.forName("javase.reflectBean.Vip");
        // 调用无参数构造方法
        Object obj1 = vipClass.newInstance();//Class类的newInstance方法
        System.out.println(obj1);

        // 使用反射机制创建对象（现在）
        // 调用有参数的构造方法怎么办？
        // 第一步：先获取到这个有参数的构造方法
        Constructor c1 = vipClass.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);
        // 第二步：调用构造方法 new 对象
        Object obj2 = c1.newInstance(321, "lsi", "1999-10-11", true);//Constructor类的newInstance方法
        System.out.println(obj2);

        // 获取无参数构造方法
        Constructor c2 = vipClass.getDeclaredConstructor();
        Object obj3 = c2.newInstance();
        System.out.println(obj3);
    }
}

/*
 重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
 */
class ReflectTest13{
    public static void main(String[] args) throws Exception{
        // String 举例
        Class vipClass = Class.forName("java.lang.String");
        // 获取 String 的父类
        Class superclass = vipClass.getSuperclass();
        // 获取 String 类实现的所有接口（一个类可以实现多个接口）
        Class[] interfaces = vipClass.getInterfaces();
        System.out.println(superclass.getName());
        for (Class i : interfaces) {
            System.out.println(i.getName());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490

JavaSE - 反射 ​

什么是反射机制 ​

反射机制作用 ​

反射机制相关的重要的类 ​

获取 Class 的三方式 ​

通过反射实例化对象 ​

导致类加载 ​

反射 Filed ​

Class 类方法 ​

Field 类方法 ​

反编译 Field ​

访问对象属性 ​

set()可以访问私有属性嘛？ ​

反射 Method ​

Method 类方法 ​

反编译 Method ​

调用对象方法 ​

反射 Constructor ​

Constructor 类方法 ​

反编译 Constructor ​

创建对象两步骤 ​

构造方法实例化对象 ​

获取类的父类以及实现的接口 ​

注意 ​

测试代码 ​

JavaSE - 反射

什么是反射机制

反射机制作用

反射机制相关的重要的类

获取 Class 的三方式

通过反射实例化对象

导致类加载

反射 Filed

Class 类方法

Field 类方法

反编译 Field

访问对象属性

set()可以访问私有属性嘛？

反射 Method

Method 类方法

反编译 Method

调用对象方法

反射 Constructor

Constructor 类方法

反编译 Constructor

创建对象两步骤

构造方法实例化对象

获取类的父类以及实现的接口

注意

测试代码